#include <iostream>
#include <tuple>
#include <type_traits>
#include <typeinfo>

template <typename T, typename Tuple>
struct HasType;

template <typename T>
struct HasType<T, std::tuple<>> : std::false_type {};

template <typename T, typename U, typename... Ts>
struct HasType<T, std::tuple<U, Ts...>>
    : std::conditional_t<std::is_same<T, U>::value,
                         std::true_type,
                         HasType<T, std::tuple<Ts...>>> {};

template <typename T, typename Tuple>
inline constexpr bool HasType_v = HasType<T, Tuple>::value;

template <typename TypeList1, typename TypeList2>
struct Merge;

template <typename... Types1, typename... Types2>
struct Merge<std::tuple<Types1...>, std::tuple<Types2...>> {
    using type =
        std::tuple<Types1...,
                   std::conditional_t<HasType_v<Types2, std::tuple<Types1...>>,
                                      std::tuple<>,
                                      std::tuple<Types2>>...>;
};

int main() {
    using TypeList1 = std::tuple<int, float, char>;
    using TypeList2 = std::tuple<char, double, int>;
    using MergedTypeList = typename Merge<TypeList1, TypeList2>::type;

    std::cout << "Type list 1: " << typeid(TypeList1).name() << std::endl;
    std::cout << "Type list 2: " << typeid(TypeList2).name() << std::endl;
    std::cout << "Merged type list: " << typeid(MergedTypeList).name()
              << std::endl;

    return 0;
}

// #include <iostream>
// #include <tuple>
// #include <type_traits>

// /* @param 类型合并的基本模板
//  * 这是 Merge 模板的基本声明，它接受两个类型列表 TypeList1 和 TypeList2。
//  */
// template <typename TypeList1, typename TypeList2>
// struct Merge;

// /* @param 类型合并的递归模板
//  * 这是 Merge 模板的递归定义。它处理 TypeList1
//  中的每个类型，检查该类型是否已经存在于合并后的类型列表中。
//  * 如果类型已存在，则跳过该类型；否则，将该类型添加到合并后的类型列表中。
//  * 这是通过使用 std::conditional_t 来实现的，它根据条件选择两个类型之一。
//  * 在这里，条件是 std::is_same_v<Head, typename Merge<std::tuple<Tail...>,
//  TypeList2>::type>，
//  * 用于检查当前类型 Head 是否已存在于合并后的类型列表中。
//  */
// template <typename Head, typename... Tail, typename TypeList2>
// struct Merge<std::tuple<Head, Tail...>, TypeList2>
//     : std::conditional_t<std::is_same_v<Head, typename
//     Merge<std::tuple<Tail...>, TypeList2>::type>,
//                          Merge<std::tuple<Tail...>, TypeList2>,
//                          decltype(std::tuple_cat(std::tuple<Head>(),
//                                                  typename
//                                                  Merge<std::tuple<Tail...>,
//                                                  TypeList2>::type()))>
//                                                  {};

// /* @param 类型合并的模板特化，用于处理空类型列表的情况
//  * 这是 Merge 模板的特化定义，用于处理 TypeList1 为空的情况。当 TypeList1
//  * 为空时，合并后的类型列表就是TypeList2 本身。
//  */
// template <typename TypeList2>
// struct Merge<std::tuple<>, TypeList2> {
//     using type = TypeList2;
// };

// int main() {
//     // 将类型列表 std::tuple<int, float, char> 和 std::tuple<char, double,
//     int> 合并为一个新的类型列表 using TypeList1      = std::tuple<int, float,
//     char>; using TypeList2      = std::tuple<char, double, int>; using
//     MergedTypeList = Merge<TypeList1, TypeList2>::type;

//     // 输出原始类型列表和合并后的类型列表，以验证合并是否正确
//     std::cout << "Type list 1: " << typeid(TypeList1).name() << std::endl;
//     std::cout << "Type list 2: " << typeid(TypeList2).name() << std::endl;
//     std::cout << "Merged type list: " << typeid(MergedTypeList).name() <<
//     std::endl;

//     return 0;
// }